As connectivity of computers and other devices has improved, it has become common for different programs—often running on different computers—to share access to the same information. In the early days of connected computing, units of data were normally transferred between programs and/or machines through specific, operator-directed events. For example, a file of data might be sent from one place to another through e-mail or File Transfer Protocol (FTP). Pipes were an early mechanism that allowed sharing of data between two running programs, but that technique is fairly limited in that it merely allows one running program to send its output to another running program as input. The architecture of modern programs often demands a richer and more sophisticated sharing of data between programs.
While some modern programs are designed to share data with each other, the implementation of data sharing can be relatively complicated from the programmer's perspective. Typically, one of the program's implementers has to write code to perform the various tasks that make data sharing work. For example, the program might include code to listen for incoming data and to send outgoing data. When two programs share data in this manner, the programs generally have to agree on mechanisms for the exchange of data. The nature of the agreed-upon mechanisms are often specific to the type of data that is being shared. For example, if multiple programs want to share graphical information, they typically have to implement a sharing mechanism that takes into account the kind of information that will be exchanged between the programs, the format in which this information will be transmitted, how conflicts among the data will be resolved (e.g., what happens if two of the programs try to update the same data at the same time), and other issues.
Thus, in order for programs to share data, the programs generally have to be implemented with the sharing of data in mind, and normally have to include code that implements the details of data sharing.